package org.jsola.hr.common;

import lombok.extern.slf4j.Slf4j;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.regex.Pattern;

/**
 * @author meng
 * 数字处理组件
 */
@Slf4j
public class NumberKit {


    public static BigDecimal pareMoneyFromFenToYuan(Integer amount, int scale, int roundingMode) {
        return new BigDecimal(amount != null ? amount : 0).divide(new BigDecimal(100), 2, roundingMode);
    }

    public static boolean isNumeric(String str) {
        Pattern pattern = Pattern.compile("[0-9]*");
        return pattern.matcher(str).matches();
    }

    /**
     * 加法
     * @param dec1 数值1
     * @param dec2 数值2
     * @return 结果
     */
    public static BigDecimal decimalAdd(BigDecimal dec1, BigDecimal dec2) {
        if (dec1 == null) {
            dec1 = new BigDecimal(0);
        }
        if (dec2 == null) {
            dec2 = new BigDecimal(0);
        }
        return dec1.add(dec2);
    }

    /**
     * 将数字转为大写
     */
    public static String toChinese(String str) {
        String[] s1 = {"零", "一", "二", "三", "四", "五", "六", "七", "八", "九"};
        String[] s2 = {"十", "百", "千", "万", "十", "百", "千", "亿", "十", "百", "千"};
        StringBuilder result = new StringBuilder();
        int n = str.length();
        for (int i = 0; i < n; i++) {
            int num = str.charAt(i) - '0';
            if (i != n - 1 && num != 0) {
                result.append(s1[num]).append(s2[n - 2 - i]);
            } else {
                result.append(s1[num]);
            }
        }
        return result.toString();
    }


    /**
     * 单位
     */
    private static String[] CN_UNITS = new String[]{"个", "十", "百", "千", "万", "十",
            "百", "千", "亿", "十", "百", "千", "万"};

    /**
     * 汉字
     */
    private static String[] CN_CHARS = new String[]{"零", "一", "二", "三", "四",
            "五", "六", "七", "八", "九"};


    /**
     * 数值转换为中文字符串(口语化)
     *
     * @param num 需要转换的数值
     * @return 数字中文字符串
     */
    public static String formatNumber(int num) {
        StringBuilder strs = new StringBuilder(32);
        String[] result = convert(num);
        for (String strNow : result) {
            strs.append(strNow);
        }
        return strs.toString();
    }

    /**
     * 将数值转换为中文
     *
     * @param num 需要转换的数值
     * @return 中文数字
     */
    private static String[] convert(int num) {
        // 10以下直接返回对应汉字
        if (num < 10) {
            return new String[]{CN_CHARS[num]};
        }

        char[] chars = String.valueOf(num).toCharArray();
        // 超过单位表示范围的返回空
        if (chars.length > CN_UNITS.length) {
            return new String[]{};
        }
        // 记录上次单位进位
        boolean isLastUnitStep = false;
        // 创建数组，将数字填入单位对应的位置
        ArrayList<String> cnchars = new ArrayList<>(chars.length * 2);
        // 从低位向高位循环
        for (int pos = chars.length - 1; pos >= 0; pos--) {
            char ch = chars[pos];
            // ascii2int 汉字
            String cnChar = CN_CHARS[ch - '0'];
            // 对应的单位坐标
            int unitPos = chars.length - pos - 1;
            // 单位
            String cnUnit = CN_UNITS[unitPos];
            // 是否为0
            boolean isZero = (ch == '0');
            // 是否低位为0
            boolean isZeroLow = (pos + 1 < chars.length && chars[pos + 1] == '0');
            // 当前位是否需要单位进位,单位进位，中文默认为4位即（万、亿）
            int unitStep = 4;
            boolean isUnitStep = (unitPos >= unitStep && (unitPos % unitStep == 0));
            // 去除相邻的上一个单位进位
            if (isUnitStep && isLastUnitStep) {
                int size = cnchars.size();
                cnchars.remove(size - 1);
                // 补0
                if (!CN_CHARS[0].equals(cnchars.get(size - 2))) {
                    cnchars.add(CN_CHARS[0]);
                }
            }
            // 单位进位(万、亿)，或者非0时加上单位
            if (isUnitStep || !isZero) {
                cnchars.add(cnUnit);
                isLastUnitStep = isUnitStep;
            }
            // 当前位为0低位为0，或者当前位为0并且为单位进位时进行省略
            if (isZero && (isZeroLow || isUnitStep)) {
                continue;
            }
            cnchars.add(cnChar);
            isLastUnitStep = false;
        }

        Collections.reverse(cnchars);
        // 清除最后一位的0
        int chSize = cnchars.size();
        String chEnd = cnchars.get(chSize - 1);
        if (CN_CHARS[0].equals(chEnd) || CN_UNITS[0].equals(chEnd)) {
            cnchars.remove(chSize - 1);
        }

        // 口语化处理
        String chFirst = cnchars.get(0);
        String chSecond = cnchars.get(1);
        // 是否以'一'开头，紧跟'十'
        if (chFirst.equals(CN_CHARS[1]) && chSecond.startsWith(CN_UNITS[1])) {
            cnchars.remove(0);
        }

        return cnchars.toArray(new String[]{});
    }

    public static void main(String[] args) {
        log.info("{}", formatNumber(1));
        log.info("{}", formatNumber(11));
        log.info("{}", formatNumber(10));
        log.info("{}", formatNumber(110));
        log.info("{}", formatNumber(100));
        log.info("{}", formatNumber(101));
    }





}
